home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / window / _leda_window.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  21.6 KB  |  986 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _leda_window.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. // defines the LEDA_WINDOW operations declared in <LEDA/leda_window.h>
  18. // using the basic graphics routines from <LEDA/impl/x_basic.h>
  19.  
  20. #include <LEDA/leda_window.h>
  21. #include <LEDA/impl/x_basic.h>
  22.  
  23. #include <stdio.h>
  24. #include <string.h>
  25. #include <ctype.h>
  26. #include <stdlib.h>
  27. #include <math.h>
  28.  
  29. color::color(const char* name) { col_index = new_color(name);  }
  30.  
  31. color::color(int i ) { col_index = i;  }
  32.  
  33. color FG_color = black;
  34. color BG_color = white;
  35.  
  36.  
  37. void LEDA_WINDOW::flush() { flush_display(); }
  38.  
  39. void LEDA_WINDOW::set_frame_label(const char* label) 
  40. { ::set_header(draw_win,label); }
  41.  
  42. int LEDA_WINDOW::load_text_font(const char* fname) 
  43. { return ::load_text_font(fname); }
  44.  
  45. int LEDA_WINDOW::load_bold_font(const char* fname) 
  46. { return ::load_bold_font(fname); }
  47.  
  48. int LEDA_WINDOW::load_message_font(const char* fname) 
  49. { return ::load_message_font(fname); }
  50.  
  51. int LEDA_WINDOW::set_font(const char* fname) 
  52. { return ::set_font(fname); }
  53.  
  54. void LEDA_WINDOW::reset_frame_label() 
  55. { ::set_header(draw_win,default_frame_label); }
  56.  
  57. void LEDA_WINDOW::set_grid_mode(int i) 
  58. { if (i != grid_mode) init(xmin(),xmax(),ymin(),i); }
  59.  
  60. drawing_mode LEDA_WINDOW::set_mode(drawing_mode m) 
  61. { drawing_mode save = drawing_mo;
  62.   drawing_mo = m;
  63.   ::set_mode(m);
  64.   return save;
  65.  }
  66.  
  67. int LEDA_WINDOW::set_line_width(int w)
  68. { if (w < 1) w = 1;
  69.   int save = line_width;
  70.   line_width = w;
  71.   ::set_line_width(w);
  72.   return save;
  73.  }
  74.  
  75. line_style LEDA_WINDOW::set_line_style(line_style s)
  76. { line_style save = line_st;
  77.   line_st = s;
  78.   ::set_line_style(s);
  79.   return save;
  80.  }
  81.  
  82. int LEDA_WINDOW::set_node_width(int w)
  83. { if (w < 1) w = 1;
  84.   int save = node_width;
  85.   node_width = w;
  86.   return save;
  87.  }
  88.  
  89. text_mode LEDA_WINDOW::set_text_mode(text_mode m)
  90. { text_mode save = text_mo;
  91.   text_mo = m;
  92.   return save;
  93.  }
  94.  
  95.  
  96. int LEDA_WINDOW::read_event(int& k, double& x, double& y)
  97. { LEDA_WINDOW* w=0;
  98.   int e = event_handler(w,1);
  99.   while (w != this) e = event_handler(w,1);
  100.   x = mouse_xreal;
  101.   y = mouse_yreal;
  102.   k = mouse_key;
  103.   return e;
  104.  }
  105.  
  106. int LEDA_WINDOW::get_event(int& k, double& x, double& y)
  107. { LEDA_WINDOW* w=0;
  108.   int e = event_handler(w,0);
  109.   while (e != no_event && w != this) e = event_handler(w,0);
  110.   x = mouse_xreal;
  111.   y = mouse_yreal;
  112.   k = mouse_key;
  113.   return e;
  114.  }
  115.  
  116. void LEDA_WINDOW::put_back_event() { ::put_back_event(); }
  117.  
  118.  
  119. int LEDA_WINDOW::event_handler(LEDA_WINDOW*& w, int blocking)
  120. {
  121.   char s[32];
  122.   Window win;
  123.  
  124.   int   val,x,y,e;
  125.  
  126.   unsigned long t;
  127.  
  128.   if (blocking)
  129.      e = get_next_event(&win, &val, &x, &y, &t);
  130.   else
  131.      e = check_next_event(&win, &val, &x, &y, &t);
  132.  
  133.   for(int i = 0; i<count && window_list[i]->draw_win != win; i++); 
  134.  
  135.   if (i >= count)  return no_event;
  136.  
  137.   w = window_list[i];
  138.  
  139.   active_window = w;
  140.  
  141.   switch (e) {
  142.  
  143.   case configure_event:
  144.            if (w->xdots != x || w->ydots != y)
  145.            { drawing_mode save = w->set_mode(src_mode);
  146.              w->init(w->min_xcoord,w->max_xcoord,w->min_ycoord,w->grid_mode);
  147.              w->set_mode(save);
  148.             }
  149.            break;
  150.  
  151.  
  152.   case button_press_event:
  153.            w->mouse_key = val;
  154.            w->mouse_xpix = x;
  155.            w->mouse_ypix = y;
  156.            w->mouse_press_time = t;
  157.            break;
  158.  
  159.   case button_release_event:
  160.            w->mouse_key = val;
  161.            w->mouse_xpix = x;
  162.            w->mouse_ypix = y;
  163.            w->mouse_release_time = t;
  164.            break;
  165.  
  166.   case motion_event:
  167.  
  168.          w->mouse_xpix = x;
  169.          w->mouse_ypix = y;
  170.  
  171.          if (w->grid_mode) w->cursor();
  172.  
  173.          w->mouse_xreal =  w->min_xcoord + ((double)w->mouse_xpix)/w->scaling;
  174.          w->mouse_yreal =  w->max_ycoord - ((double)w->mouse_ypix)/w->scaling;
  175.         
  176.          if (blocking)
  177.          { if (w->grid_mode)
  178.            { int g = w->grid_mode;
  179.              w->mouse_xreal = g*(int)(w->mouse_xreal/g +((w->mouse_xreal>0) ? 0.5:-0.5));
  180.              w->mouse_yreal = g*(int)(w->mouse_yreal/g +((w->mouse_yreal>0) ? 0.5:-0.5));
  181.              w->mouse_xpix  = w->xpix(w->mouse_xreal);
  182.              w->mouse_ypix  = w->ypix(w->mouse_yreal);
  183.              w->cursor();
  184.             }
  185.      
  186.            if (w->show_coord && blocking)
  187.            { sprintf(s,"%8.2f %8.2f\0", w->mouse_xreal,w->mouse_yreal);
  188.              show_coordinates(win,s);
  189.             }
  190.           
  191.            if (w->mouse_action && w == read_window) /* user defined action */
  192.            { w->mouse_action(w->mouse_last_xreal,w->mouse_last_yreal);
  193.              w->mouse_action(w->mouse_xreal,w->mouse_yreal);
  194.             }
  195.           }
  196.       
  197.          w->mouse_last_xreal = w->mouse_xreal;
  198.          w->mouse_last_yreal = w->mouse_yreal;
  199.  
  200.      }
  201.  
  202.   return e;
  203. }
  204.  
  205.  
  206. int LEDA_WINDOW::read_mouse(int kind, double xstart, double ystart, double &x, double &y)
  207. { 
  208.   // 0: point, 1: segment, 2:rectangle, 3: circle 
  209.  
  210.   switch(kind) {
  211.   case  0: return read_mouse_action(mouse_default_action,xstart,ystart,x,y);
  212.   case  1: return read_mouse_action(mouse_segment_action,xstart,ystart,x,y);
  213.   case  2: return read_mouse_action(mouse_rect_action,xstart,ystart,x,y);
  214.   case  3: return read_mouse_action(mouse_circle_action,xstart,ystart,x,y);
  215.   default: return read_mouse_action(mouse_default_action,xstart,ystart,x,y);
  216.   }
  217.  
  218. }
  219.  
  220.  
  221. int LEDA_WINDOW::get_button(double &x, double &y)
  222. { mouse_key = 0;
  223.   drawing_mode s = set_mode(xor_mode);
  224.   set_read_gc();
  225.   LEDA_WINDOW* w;
  226.   int e = event_handler(w,0);
  227.   while (e != no_event && e != button_press_event && w != this) 
  228.       e = event_handler(w,0);
  229.   reset_gc();
  230.   set_mode(s);
  231.   x = mouse_xreal;
  232.   y = mouse_yreal;
  233.   return mouse_key;
  234.  }
  235.  
  236. unsigned long LEDA_WINDOW::button_press_time()  { return mouse_press_time; }
  237. unsigned long LEDA_WINDOW::button_release_time(){ return mouse_release_time; }
  238.  
  239.  
  240. int LEDA_WINDOW::read_mouse_action(mouse_action_func_ptr action, double xstart, double ystart, double &x, double &y)
  241. {
  242.   read_window = this;
  243.  
  244.   mouse_action = action;
  245.  
  246.   drawing_mode s = set_mode(xor_mode);
  247.   set_read_gc();
  248.  
  249.   mouse_key = 0;
  250.  
  251.   mouse_start_xreal = xstart;
  252.   mouse_start_yreal = ystart;
  253.  
  254.   mouse_start_xpix = xpix(xstart);
  255.   mouse_start_ypix = ypix(ystart);
  256.  
  257.   if (grid_mode) cursor();
  258.  
  259.   if (show_coord)
  260.   { char s[64];
  261.     sprintf(s,"%8.2f %8.2f\0", mouse_xreal,mouse_yreal);
  262.     show_coordinates(draw_win,s);
  263.    }
  264.  
  265.   if (mouse_action) mouse_action(mouse_last_xreal,mouse_last_yreal);
  266.  
  267.   LEDA_WINDOW* w;
  268.  
  269.   while (event_handler(w,1) != button_press_event || w != this);
  270.  
  271.   if (mouse_action) mouse_action(mouse_xreal,mouse_yreal);
  272.  
  273.   if (grid_mode) cursor();
  274.  
  275.   x = mouse_xreal;
  276.   y = mouse_yreal;
  277.  
  278.   reset_gc();
  279.   set_mode(s);
  280.  
  281.   mouse_action = mouse_default_action;
  282.  
  283.   return mouse_key;
  284. }
  285.  
  286.  
  287. void LEDA_WINDOW::close() 
  288. { if (draw_win)
  289.   { int i = 0;
  290.     while (window_list[i] != this) i++;
  291.     count--;
  292.     window_list[i] = window_list[count];
  293.     close_window(draw_win); 
  294.     draw_win = 0;
  295.     if (count==0) close_display(); 
  296.    }
  297.  }
  298.  
  299.  
  300.  
  301. LEDA_WINDOW::LEDA_WINDOW(float width, float height, float xpos, float ypos, 
  302.                                                       const char *frame_label)
  303. { ref_count = 1;
  304.   state = 1;
  305.   draw_win = 0;
  306.   open(int(width),int(height),int(xpos),int(ypos),frame_label);
  307.  }
  308.  
  309.  
  310. LEDA_WINDOW::LEDA_WINDOW(float width, float height, const char* frame_label)
  311. { ref_count = 1;
  312.   state = 1;
  313.   draw_win = 0;
  314.   open(int(width),int(height),-3,-1,frame_label); 
  315.  }
  316.  
  317. LEDA_WINDOW::LEDA_WINDOW(const char* frame_label)
  318. { ref_count = 1;
  319.   state = 1;
  320.   draw_win = 0;
  321.   int l  =  screen_height() - 35;
  322.   if (l > 700) l = 700;
  323.   open(l,l,-3,-1,frame_label);
  324.  }
  325.  
  326. LEDA_WINDOW::LEDA_WINDOW()
  327. { ref_count = 1;
  328.   state = 1;
  329.   draw_win = 0;
  330.   //int l  =  screen_height() - 35;
  331.   //if (l > 700) l = 700;
  332.   //open(l,l,-3,-1,"");
  333.  }
  334.  
  335. LEDA_WINDOW::LEDA_WINDOW(const LEDA_WINDOW& w)
  336. { state = w.state;
  337.   ref_count = w.ref_count+1;
  338.   draw_win = w.draw_win;
  339.  }
  340.  
  341. LEDA_WINDOW::~LEDA_WINDOW() 
  342. { if (--ref_count == 0) close(); }
  343.  
  344.  
  345. LEDA_WINDOW& LEDA_WINDOW::operator=(const LEDA_WINDOW& w)
  346. { if (&w != this)
  347.   { if (--ref_count == 0) close();
  348.     state = w.state;
  349.     ref_count = w.ref_count + 1;
  350.     draw_win = w.draw_win;
  351.    }
  352.   return *this;
  353.  }
  354.  
  355.  
  356.  
  357. void LEDA_WINDOW::open(int w_width, int w_height, int w_xpos, int w_ypos, 
  358.                                                       const char *frame_label)
  359. {
  360.   if (draw_win) return;
  361.  
  362.   active_window = this;
  363.  
  364.   default_frame_label[0] = 0;
  365.  
  366.   if (frame_label) strcpy(default_frame_label,frame_label);
  367.  
  368.   if (count==0) open_display();
  369.  
  370.   window_list[count] = this;
  371.  
  372.   count++;
  373.  
  374.   if (w_xpos < 0)
  375.     switch (w_xpos) {
  376.     case -1 : w_xpos = 0;
  377.               break;
  378.     case -2 : w_xpos = (screen_width() - w_width - 10)/2;
  379.               break;
  380.     case -3 : w_xpos = (screen_width() - w_width - 10);
  381.               break;
  382.     default : w_xpos = 0;
  383.     }
  384.  
  385.   if (w_ypos < 0)
  386.     switch (w_ypos) {
  387.     case -1 : w_ypos = 0;
  388.               break;
  389.     case -2 : w_ypos = (screen_height() - w_height - 30)/2;
  390.               break;
  391.     case -3 : w_ypos = (screen_height() - w_height - 30);
  392.               break;
  393.     default : w_ypos = 0;
  394.     }
  395.  
  396.   draw_win = open_window(w_xpos, w_ypos, w_width, w_height,
  397.                          default_frame_label,"LEDA WINDOW");
  398.   set_color(black);
  399.   set_text_font();
  400.  
  401.   set_mode(src_mode);
  402.   set_line_style(solid);
  403.   set_line_width(1);
  404.   set_node_width(12);
  405.   set_text_mode(transparent);
  406.  
  407.   set_show_coordinates(1);
  408.  
  409.   redraw = 0;
  410.  
  411.   depth = display_depth();
  412.   min_xcoord = 0;
  413.   min_ycoord = 0;
  414.   max_xcoord = 0;
  415.   max_ycoord = 0;
  416.   scaling = 1;
  417.   mouse_xpix = 0;
  418.   mouse_ypix = 0;
  419.  
  420.   mesg_count = 0;
  421.  
  422.   screen_flush = 1;
  423.  
  424.   window_xpos = w_xpos;
  425.   window_ypos = w_ypos;
  426.   window_width = w_width;
  427.   window_height = w_height;
  428.  
  429.   init(0,100,0,0);
  430. }
  431.  
  432.  
  433. void LEDA_WINDOW::init(double x0, double x1, double y0, int g_mode)
  434. {
  435.  if (x0 >= x1)
  436.  { fprintf(stderr,"Illegal arguments in draw_init: x0 (%f) >= x1 (%f)\n",x0,x1);
  437.    abort();
  438.   }
  439.  
  440.   grid_mode = g_mode;
  441.  
  442.  
  443.   xdots = ::window_width(draw_win);
  444.   ydots = ::window_height(draw_win);
  445.  
  446.  
  447.   scaling = ((double)xdots)/(x1-x0);
  448.  
  449.   /* at least grid distance of 2 pixels */
  450.   if ((grid_mode) && (grid_mode*scaling < 2))
  451.   { grid_mode=0; 
  452.     fprintf(stderr,"warning: grid distance to small.\n");
  453.    }
  454.  
  455.   if (grid_mode)
  456.   { if (scaling < 1) scaling = 1;
  457.     else scaling = (int)scaling;
  458.   }
  459.  
  460.   min_xcoord = x0;
  461.   min_ycoord = y0;
  462.   max_xcoord = x0+xdots/scaling;
  463.   max_ycoord = y0+ydots/scaling;
  464.  
  465.   xorigin = (int)(-x0*scaling);
  466.   yorigin = (int)(ydots+y0*scaling);
  467.  
  468.   mouse_xreal = 0;
  469.   mouse_yreal = 0;
  470.  
  471.   clear(0);  
  472.  
  473.   if (redraw) (*redraw)();
  474.  
  475.   flush_display();
  476.  
  477. }
  478.  
  479.  
  480. void LEDA_WINDOW::draw_pix(double x, double y, int col)
  481. { set_color(col);
  482.   pixel(draw_win,xpix(x),ypix(y));
  483.   if (screen_flush) flush_display();
  484. }
  485.  
  486.  
  487. void LEDA_WINDOW::draw_segment(double x1, double y1, double x2, double y2, int col)
  488. { set_color(col);
  489.   line(draw_win, xpix(x1), ypix(y1), xpix(x2), ypix(y2));
  490.   if (screen_flush) flush_display();
  491. }
  492.  
  493.  
  494. void LEDA_WINDOW::draw_point(double x, double y, int col)
  495. { int X = xpix(x);
  496.   int Y = ypix(y);
  497.   set_color(col);
  498.   pixel(draw_win,X-2,Y-2);
  499.   pixel(draw_win,X+2,Y-2);
  500.   pixel(draw_win,X-1,Y-1);
  501.   pixel(draw_win,X+1,Y-1);
  502.   pixel(draw_win,X,Y);
  503.   pixel(draw_win,X-1,Y+1);
  504.   pixel(draw_win,X+1,Y+1);
  505.   pixel(draw_win,X-2,Y+2);
  506.   pixel(draw_win,X+2,Y+2);
  507.   if (screen_flush) flush_display();
  508. }
  509.  
  510.  
  511. void LEDA_WINDOW::draw_arc(double x0, double y0, double r1, double r2, double start, double angle, int col)
  512. { int R1 = (int)(r1*scaling);
  513.   int R2 = (int)(r2*scaling);
  514.   set_color(col);
  515.   arc(draw_win,xpix(x0),ypix(y0),R1,R2,start,angle);
  516.   if (screen_flush) flush_display();
  517. }
  518.  
  519. void LEDA_WINDOW::draw_filled_arc(double x0, double y0, double r1, double r2, double start, double angle, int col)
  520. { int R1 = (int)(r1*scaling);
  521.   int R2 = (int)(r2*scaling);
  522.   set_color(col);
  523.   fill_arc(draw_win,xpix(x0),ypix(y0),R1,R2,start,angle);
  524.   if (screen_flush) flush_display();
  525. }
  526.  
  527.  
  528. void LEDA_WINDOW::draw_node(double x0, double y0, int col)
  529. { int save = set_line_width(1);
  530.   double R = node_width/scaling;
  531.   draw_circle(x0,y0,R,col);
  532.   set_line_width(save);
  533.  }
  534.  
  535. void LEDA_WINDOW::draw_filled_node(double x0, double y0, int col)
  536. { double R = node_width/scaling;
  537.   if (depth==1 && col!=white) col = black;
  538.   draw_filled_circle(x0,y0,R,col);
  539.   if (col != black) 
  540.   { int save = set_line_width(1);
  541.     draw_circle(x0,y0,R,col);
  542.     draw_circle(x0,y0,R,black);
  543.     set_line_width(save);
  544.    }
  545.  }
  546.  
  547.  
  548. void LEDA_WINDOW::draw_text_node(double x0, double y0, char *s, int col)
  549. { text_mode t_save = set_text_mode(transparent);
  550.   set_bold_font();
  551.  
  552.   if (depth==1 && col!=black) col = white;
  553.   draw_filled_node(x0,y0,col);
  554.   
  555.   draw_ctext(x0,y0,s,col);
  556.  
  557.   if (col == black) 
  558.      draw_ctext(x0,y0,s,white);
  559.   else
  560.      draw_ctext(x0,y0,s,black);
  561.  
  562.   set_text_mode(t_save);
  563.   set_text_font();
  564. }
  565.  
  566. void LEDA_WINDOW::draw_int_node(double x0, double y0, int i, int col)
  567. { char buf[16];
  568.   sprintf(buf,"%d",i);
  569.   draw_text_node(x0,y0,buf,col);
  570.  }
  571.  
  572.  
  573. void LEDA_WINDOW::draw_edge(double x1, double y1, double x2, double y2, int col)
  574. { double dx = x2-x1;
  575.   double dy = y2-y1;
  576.   if (dx==0 && dy==0) return;
  577.   double l = node_width/(scaling*hypot(dx,dy));
  578.   x1 += l*dx;
  579.   x2 -= l*dx;
  580.   y1 += l*dy;
  581.   y2 -= l*dy;
  582.   draw_segment(x1,y1,x2,y2,col);
  583. }
  584.  
  585.  
  586.  
  587. void LEDA_WINDOW::draw_circle(double x0, double y0, double r, int col)
  588. { int R = (int)(r*scaling);
  589.   set_color(col);
  590.   circle(draw_win,xpix(x0),ypix(y0),R);
  591.   if (screen_flush) flush_display();
  592.  }
  593.  
  594.  
  595. void LEDA_WINDOW::draw_filled_circle(double x0, double y0, double r, int col)
  596. { int R = (int)(r*scaling);
  597.   set_color(col);
  598.   if (R > 0)
  599.      fill_circle(draw_win,xpix(x0),ypix(y0),R);
  600.   else
  601.      pixel(draw_win,xpix(x0),ypix(y0));
  602.   if (screen_flush) flush_display();
  603.  }
  604.  
  605.  
  606. void LEDA_WINDOW::draw_ellipse(double x0, double y0, double a, double b, int col)
  607. { int R1 = (int)(a*scaling);
  608.   int R2 = (int)(b*scaling);
  609.   set_color(col);
  610.   ellipse(draw_win,xpix(x0),ypix(y0),R1,R2);
  611.   if (screen_flush) flush_display();
  612.  }
  613.  
  614.  
  615. void LEDA_WINDOW::draw_filled_ellipse(double x0, double y0, double a, double b, int col)
  616. { int R1 = (int)(a*scaling);
  617.   int R2 = (int)(b*scaling);
  618.   set_color(col);
  619.   fill_ellipse(draw_win,xpix(x0),ypix(y0),R1,R2);
  620.   if (screen_flush) flush_display();
  621.  }
  622.  
  623.  
  624.  
  625. void LEDA_WINDOW::plot_xy(double x0, double x1, double (*f) (double), int col)
  626. {
  627.   int *xcoord;
  628.   int *ycoord;
  629.  
  630.   int x = xpix(x0);
  631.   int y_old = ypix((*f)(x0));
  632.   int i,y_new;
  633.   int size = 0;
  634.   int n = 0;
  635.  
  636.   set_color(col);
  637.  
  638.   for(x = xpix(x0)+1; x <= xpix(x1); x++)
  639.   { y_new = ypix((*f)(xreal(x)));
  640.     if (y_new > y_old)
  641.        size += (y_new-y_old+1);
  642.     else
  643.        size += (y_old-y_new+1);
  644.     y_old = y_new;
  645.    }
  646.  
  647.   xcoord = (int*) malloc(size*sizeof(int));
  648.   ycoord = (int*) malloc(size*sizeof(int));
  649.  
  650.   y_old = ypix((*f)(x0));
  651.  
  652.   for(x = xpix(x0)+1; x <= xpix(x1); x++)
  653.   { y_new = ypix((*f)(xreal(x)));
  654.     if (y_new > y_old)
  655.       for(i=y_old; i<=y_new; i++) 
  656.       { xcoord[n] = x;
  657.         ycoord[n] = i;
  658.         n++;
  659.        }
  660.     else
  661.       for(i=y_old; i>=y_new; i--) 
  662.       { xcoord[n] = x;
  663.         ycoord[n] = i;
  664.         n++;
  665.        }
  666.     y_old = y_new;
  667.   }
  668.  
  669.  pixels(draw_win,size,xcoord,ycoord);
  670.  
  671.  free((char*)xcoord);
  672.  free((char*)ycoord);
  673.  
  674.   if (screen_flush) flush_display();
  675. }
  676.  
  677.  
  678. void LEDA_WINDOW::plot_yx(double y0, double y1, double (*f) (double), int col)
  679. {
  680.   int *xcoord;
  681.   int *ycoord;
  682.  
  683.   int y;
  684.   int i,x_new;
  685.   int x_old = xpix((*f)(y0));
  686.   int size = 0;
  687.   int n = 0;
  688.  
  689.   set_color(col);
  690.  
  691.   for(y = ypix(y0)-1; y >= ypix(y1); y++)
  692.   { x_new = xpix((*f)(yreal(y)));
  693.     if (x_new > x_old)
  694.        size += (x_new-x_old+1);
  695.     else
  696.        size += (x_old-x_new+1);
  697.     x_old = x_new;
  698.    }
  699.  
  700.   xcoord = (int*) malloc(size*sizeof(int));
  701.   ycoord = (int*) malloc(size*sizeof(int));
  702.  
  703.   x_old = xpix((*f)(y0));
  704.  
  705.   for(y = ypix(y0)-1; y >= ypix(y1); y--)
  706.   {
  707.     x_new = xpix((*f)(yreal(y)));
  708.     if (x_new > x_old)
  709.       for(i=x_old; i<=x_new; i++) 
  710.       { xcoord[n] = i;
  711.         ycoord[n] = y;
  712.         n++;
  713.        }
  714.     else
  715.       for(i=x_old; i>=x_new; i--) 
  716.       { xcoord[n] = i;
  717.         ycoord[n] = y;
  718.         n++;
  719.        }
  720.     x_old = x_new;
  721.   }
  722.  
  723.  pixels(draw_win,size,xcoord,ycoord);
  724.  
  725.  free((char*)xcoord);
  726.  free((char*)xcoord);
  727.  
  728.  if (screen_flush) flush_display();
  729. }
  730.  
  731.  
  732. void LEDA_WINDOW::draw_filled_polygon(int n, double *xcoord, double *ycoord, int col)
  733. {
  734.  int* x = (int*) malloc(n*sizeof(int));
  735.  int* y = (int*) malloc(n*sizeof(int));
  736.  int i;
  737.  
  738.  for(i=0;i<n;i++)
  739.  { x[i] = xpix(xcoord[i]);
  740.    y[i] = ypix(ycoord[i]);
  741.   }
  742.  
  743.  set_color(col);
  744.  
  745.  fill_polygon(draw_win,n,x,y);
  746.  
  747.  free((char*)x);
  748.  free((char*)y);
  749.  
  750.   if (screen_flush) flush_display();
  751. }
  752.  
  753. void LEDA_WINDOW::draw_polygon(int n, double *xcoord, double *ycoord, int col)
  754. { int i;
  755.  
  756.   for(i=0;i<n-1;i++)
  757.     draw_segment(xcoord[i],ycoord[i], xcoord[i+1],ycoord[i+1],col);
  758.  
  759.   draw_segment(xcoord[n-1],ycoord[n-1],xcoord[0],ycoord[0],col);
  760.  
  761.   if (screen_flush) flush_display();
  762.  
  763.  }
  764.  
  765.  
  766. void LEDA_WINDOW::draw_rectangle(double x1, double y1, double x2, double y2, int col)
  767. { set_color(col);
  768.   rectangle(draw_win,xpix(x1),ypix(y1),xpix(x2),ypix(y2));
  769.   if (screen_flush) flush_display();
  770.  }
  771.  
  772.  
  773. void LEDA_WINDOW::draw_filled_rectangle(double x1, double y1, double x2, double y2, int col)
  774. { set_color(col);
  775.   box(draw_win,xpix(x1),ypix(y1),xpix(x2),ypix(y2));
  776.   if (screen_flush) flush_display();
  777.  }
  778.  
  779.  
  780. void LEDA_WINDOW::copy_rect(double x1, double y1, double x2, double y2, double x, double y)
  781. { ::copy_rect(draw_win,xpix(x1),ypix(y1),xpix(x2),ypix(y2),xpix(x),ypix(y));
  782.   if (screen_flush) flush_display();
  783.  }
  784.  
  785. void LEDA_WINDOW::insert_bitmap(int width, int height, char* data)
  786. { ::insert_bitmap(draw_win,width,height,data);
  787.   if (screen_flush) flush_display();
  788.  }
  789.  
  790.  
  791. void LEDA_WINDOW::clear(int col)
  792. { int x0,y0,n;
  793.   double x,y;
  794.  
  795.   int *xcoord;
  796.   int *ycoord;
  797.  
  798.   int save_lw = set_line_width(1);
  799.   line_style save_ls = set_line_style(solid);
  800.  
  801.  del_messages();
  802.  
  803.  if (depth == 1) col = 0;
  804.  
  805.  clear_window(draw_win,col);
  806.  
  807.  set_color(black);
  808.  
  809.  if (grid_mode) /* draw grid */
  810.  { n =  (int)((max_xcoord - min_xcoord)/grid_mode + 1);
  811.    n *= (int)((max_ycoord - min_ycoord)/grid_mode + 1);
  812.  
  813.    x0 = ((int)(min_xcoord/grid_mode))*grid_mode;
  814.    y0 = ((int)(min_ycoord/grid_mode))*grid_mode;
  815.  
  816.    xcoord = (int *) malloc(n*sizeof(int));
  817.    ycoord = (int *) malloc(n*sizeof(int));
  818.  
  819.    n = 0;
  820.  
  821.    for(x = x0; x<=max_xcoord; x+=grid_mode)
  822.    for(y = y0; y<=max_ycoord; y+=grid_mode)
  823.    { if (x == 0 || y == 0)
  824.         fill_circle(draw_win,xpix(x),ypix(y),1);
  825.      else
  826.         { xcoord[n] = xpix(x);
  827.           ycoord[n] = ypix(y);
  828.           n++;
  829.          }
  830.     }
  831.  
  832.    pixels(draw_win,n,xcoord,ycoord);
  833.  
  834.    free((char*)xcoord);
  835.    free((char*)ycoord);
  836.   }
  837.  
  838.  set_line_width(save_lw);
  839.  set_line_style(save_ls);
  840.  
  841.  flush_display();
  842. }
  843.  
  844.  
  845.  
  846. void LEDA_WINDOW::message(const char *s)
  847. { drawing_mode save = set_mode(xor_mode);
  848.  
  849.   mesg_list[mesg_count] = (char*)malloc(strlen(s)+1);
  850.   strcpy(mesg_list[mesg_count],s);
  851.  
  852.   mesg_count++;
  853.  
  854.   set_color(black);
  855.   set_message_font();
  856.   int h = int(1.3 * text_height("H"));
  857.   put_text(draw_win,20,10+h*mesg_count,s,0);
  858.   set_text_font();
  859.   set_mode(save);
  860.   flush_display();
  861. }
  862.  
  863.  
  864. void LEDA_WINDOW::del_messages(void)
  865. { drawing_mode save = set_mode(xor_mode);
  866.   set_color(black);
  867.   set_message_font();
  868.   int h = int(1.3 * text_height("H"));
  869.   while(mesg_count > 0)
  870.   { char* s = mesg_list[mesg_count-1];
  871.     put_text(draw_win,20,10+h*mesg_count,s,0);
  872.     mesg_count--;
  873.     free(s);
  874.    }
  875.   set_text_font();
  876.   set_mode(save);
  877.   flush_display();
  878. }
  879.  
  880.  
  881.  
  882. void LEDA_WINDOW::draw_text(double x, double y, const char *s, int col)
  883. { set_color(col);
  884.   put_text(draw_win,xpix(x),ypix(y),s,text_mo);
  885.   if (screen_flush) flush_display();
  886. }
  887.  
  888.  
  889. void LEDA_WINDOW::draw_ctext(double x, double y, const char *s, int col)
  890. { set_color(col);
  891.   put_ctext(draw_win,xpix(x),ypix(y),s,text_mo);
  892.   if (screen_flush) flush_display();
  893. }
  894.  
  895. void LEDA_WINDOW::cursor(void)
  896. { int X = xpix(mouse_xreal);
  897.   int Y = ypix(mouse_yreal);
  898.   line(draw_win, X,Y,X+10,Y);
  899.   line(draw_win, X,Y,X-10,Y);
  900.   line(draw_win, X,Y,X,Y+10);
  901.   line(draw_win, X,Y,X,Y-10);
  902. }
  903.  
  904. // define static members
  905.  
  906. LEDA_WINDOW* LEDA_WINDOW::window_list[32];
  907. LEDA_WINDOW* LEDA_WINDOW::read_window = 0;
  908. LEDA_WINDOW* LEDA_WINDOW::active_window = 0;
  909. int          LEDA_WINDOW::count = 0;
  910.  
  911. int  LEDA_WINDOW::screen_width(void)  { return display_width(); }
  912. int  LEDA_WINDOW::screen_height(void) { return display_height(); }
  913. int  LEDA_WINDOW::screen_depth(void)  { return display_depth(); }
  914.  
  915. void LEDA_WINDOW::mouse_default_action(double,double) 
  916. { /* do nothing */}
  917.  
  918. void LEDA_WINDOW::mouse_segment_action(double x, double y) 
  919. { double x0 = read_window->mouse_start_xreal;
  920.   double y0 = read_window->mouse_start_yreal;
  921.   read_window->draw_segment(x0,y0,x,y,black); 
  922.  }
  923.  
  924. void LEDA_WINDOW::mouse_rect_action(double x, double y)
  925. { double x0 = read_window->mouse_start_xreal;
  926.   double y0 = read_window->mouse_start_yreal;
  927.   read_window->draw_rectangle(x0,y0,x,y,black);
  928.  }
  929.  
  930. void LEDA_WINDOW::mouse_circle_action(double x, double y)
  931. { double x0 = read_window->mouse_start_xreal;
  932.   double y0 = read_window->mouse_start_yreal;
  933.   read_window->draw_circle(x0,y0,hypot(x-x0,y-y0),black);
  934.  }
  935.  
  936.  
  937. #include <fstream.h>
  938.  
  939. char* Read_Leda_Bitmap(const char* fname, int& w, int& h)
  940. {
  941.   ifstream bitmap(fname);
  942.  
  943.   unsigned char c1,c2;
  944.  
  945.   bitmap.get(c1);
  946.   bitmap.get(c2);
  947.   w = c2;
  948.   w *= 256;
  949.   w += c1;
  950.  
  951.   bitmap.get(c1);
  952.   bitmap.get(c2);
  953.   h = c2;
  954.   h *= 256;
  955.   h += c1;
  956.  
  957.   int n = w*h/8;
  958.  
  959.   char* map = new char[n];
  960.  
  961.   int i = 0;
  962.   while(i<n && bitmap) 
  963.   { char c;
  964.     bitmap.get(c);
  965.     if (c == char(0xff) || c == char(0x00))
  966.        { unsigned char j;
  967.          bitmap.get(j);
  968.          while (j--) map[i++] = c;
  969.         }
  970.     else 
  971.        map[i++] = c;
  972.    }
  973.  
  974.   return map;
  975. }
  976.  
  977.  
  978.  
  979. int read_mouse(LEDA_WINDOW*& w, double& x, double& y)
  980. { int e = LEDA_WINDOW::event_handler(w,1);
  981.   while (e != button_press_event) e = LEDA_WINDOW::event_handler(w,1);
  982.   x = w->mouse_xreal;
  983.   y = w->mouse_yreal;
  984.   return w->mouse_key;
  985.  }
  986.